home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / Main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  20.7 KB  |  760 lines  |  [TEXT/KAHL]
  1. /* Main.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #define Including_Main_c
  26.  
  27. #include "MiscInfo.h"
  28. #include "Audit.h"
  29. #include "Debug.h"
  30. #include "Definitions.h"
  31.  
  32. #include "Main.h"
  33. #include "Screen.h"
  34. #include "Alert.h"
  35. #include "Scroll.h"
  36. #include "GrowIcon.h"
  37. #include "StartupOpen.h"
  38. #include "DataMunging.h"
  39. #include "Memory.h"
  40. #include "MainWindowStuff.h"
  41. #include "WindowDispatcher.h"
  42. #include "AboutBox.h"
  43. #include "EditImages.h"
  44. #include "NoteImages.h"
  45. #include "NoteButtonImages.h"
  46. #include "LittleButtonImages.h"
  47. #include "Factoring.h"
  48. #include "Files.h"
  49. #include "GlobalWindowMenuList.h"
  50. #include "PlayAIFFFile.h"
  51.  
  52.  
  53. #define STARTUPDELAY (3)
  54.  
  55.  
  56. char*                            GlobalSearchString;
  57. char*                            GlobalReplaceString;
  58.  
  59. MenuType*                    mmAppleMenu;
  60. MenuType*                    mmFileMenu;
  61. MenuType*                    mmEditMenu;
  62. MenuType*                    mmSearchMenu;
  63. MenuType*                    mmObjectsMenu;
  64. MenuType*                    mmFunctionMenu;
  65. MenuType*                    mmSampleMenu;
  66. MenuType*                    mmWindowMenu;
  67.  
  68. MenuItemType*            mAboutThisProgram;
  69. MenuItemType*            mNewFile;
  70. MenuItemType*            mOpenFile;
  71. MenuItemType*            mCloseFile;
  72. MenuItemType*            mSaveFile;
  73. MenuItemType*            mSaveAs;
  74. MenuItemType*            mSetTabSize;
  75. MenuItemType*            mPlay;
  76. MenuItemType*            mPlayThisTrackFromHere;
  77. MenuItemType*            mPlayAllTracksFromHere;
  78. MenuItemType*            mPlayAIFFFile;
  79. MenuItemType*            mQuit;
  80.  
  81. MenuItemType*            mUndo;
  82. MenuItemType*            mCut;
  83. MenuItemType*            mCopy;
  84. MenuItemType*            mPaste;
  85. MenuItemType*            mClear;
  86. MenuItemType*            mSelectAll;
  87. MenuItemType*            mShiftLeft;
  88. MenuItemType*            mShiftRight;
  89. MenuItemType*            mBalanceParens;
  90. MenuItemType*            mEnterSelection;
  91. MenuItemType*            mFind;
  92. MenuItemType*            mFindAgain;
  93. MenuItemType*            mReplace;
  94. MenuItemType*            mReplaceAndFindAgain;
  95. MenuItemType*            mShowSelection;
  96.  
  97. MenuItemType*            mNewSample;
  98. MenuItemType*            mNewFunction;
  99. MenuItemType*            mNewAlgoSample;
  100. MenuItemType*            mNewWaveTable;
  101. MenuItemType*            mNewAlgoWaveTable;
  102. MenuItemType*            mNewTrack;
  103. MenuItemType*            mNewInstrument;
  104. MenuItemType*            mBuildFunction;
  105. MenuItemType*            mUnbuildFunction;
  106. MenuItemType*            mUnbuildAllFunctions;
  107. MenuItemType*            mBuildEntireProject;
  108. MenuItemType*            mDisassembleFunction;
  109. MenuItemType*            mOpenObject;
  110. MenuItemType*            mEditTrackAttributes;
  111. MenuItemType*            mDeleteObject;
  112. MenuItemType*            mCalculator;
  113. MenuItemType*            mEvaluateCalc;
  114. MenuItemType*            mAlgoSampToSample;
  115. MenuItemType*            mSampleEditLoop1;
  116. MenuItemType*            mSampleEditLoop2;
  117. MenuItemType*            mSampleEditLoop3;
  118. MenuItemType*            mImportWAVFormat;
  119. MenuItemType*            mImportAIFFFormat;
  120. MenuItemType*            mImportRAWFormat;
  121. MenuItemType*            mExportWAVFormat;
  122. MenuItemType*            mExportAIFFFormat;
  123. MenuItemType*            mExportRAWFormat;
  124. MenuItemType*            mCopyObject;
  125. MenuItemType*            mPasteObject;
  126. MenuItemType*            mTransposeSelection;
  127. MenuItemType*            mGotoMeasureBar;
  128.  
  129.  
  130. int                                main(int argc, char* argv[])
  131.     {
  132.         MyBoolean                TryToOpenUntitledDocument;
  133.         MyBoolean                ContinueFlag;
  134. #if 0
  135.         double                    StartupTime;
  136.         MyBoolean                InitialAboutBoxStillVisible;
  137. #endif
  138.  
  139.         APRINT(("+main"));
  140.  
  141.         /* level 0 initialization */
  142.         if (!InitializeScreen())
  143.             {
  144.                 goto InitScreenFailurePoint;
  145.             }
  146.         SetErrorBeepEnable(False); /* it's a music program, so disable nasty noises */
  147.  
  148.         /* level 1 initialization */
  149.         if (!InitializeAlertSubsystem())
  150.             {
  151.                 goto InitAlertFailurePoint;
  152.             }
  153.         if (!InitializeGrowIcon())
  154.             {
  155.                 goto InitGrowIconFailurePoint;
  156.             }
  157.  
  158.         /* application initialization */
  159.         if (!InitializeFactoring())
  160.             {
  161.                 goto InitFactoringFailurePoint;
  162.             }
  163.         if (!InitializeEditImages())
  164.             {
  165.                 goto InitEditImagesFailurePoint;
  166.             }
  167.         if (!InitializeNoteImages())
  168.             {
  169.                 goto InitNoteImagesFailurePoint;
  170.             }
  171.         if (!InitializeNoteButtonImages())
  172.             {
  173.                 goto InitNoteButtonImagesFailurePoint;
  174.             }
  175.         if (!InitializeLittleButtonImages())
  176.             {
  177.                 goto InitializeLittleButtonImagesFailurePoint;
  178.             }
  179.         if (!InitializeWindowDispatcher())
  180.             {
  181.                 goto InitWindowDispatcherFailurePoint;
  182.             }
  183.         if (!InitializeDocuments())
  184.             {
  185.                 goto InitDocumentsFailurePoint;
  186.             }
  187.         GlobalSearchString = AllocPtrCanFail(0,"GlobalSearchString");
  188.         if (GlobalSearchString == NIL)
  189.             {
  190.                 goto AllocGlobalSearchStringFailurePoint;
  191.             }
  192.         GlobalReplaceString = AllocPtrCanFail(0,"GlobalReplaceString");
  193.         if (GlobalReplaceString == NIL)
  194.             {
  195.                 goto AllocGlobalReplaceStringFailurePoint;
  196.             }
  197.         if (!InitializeGlobalWindowMenuList())
  198.             {
  199.                 goto InitializeGlobalMenuWindowListFailurePoint;
  200.             }
  201.  
  202. #if 0
  203. #if !DEBUG
  204.         ShowAboutBox();
  205. #endif
  206.         InitialAboutBoxStillVisible = True;
  207.         StartupTime = ReadTimer();
  208. #endif
  209.  
  210.         mmAppleMenu = MakeAppleMenu();
  211.         if (mmAppleMenu == NIL)
  212.             {
  213.                 goto MakeAppleMenuFailurePoint;
  214.             }
  215.         mAboutThisProgram = MakeNewMenuItem(mmAppleMenu,"About Out Of Phase...",0);
  216.         if (mAboutThisProgram == NIL)
  217.             {
  218.                 goto MakeFileMenuFailurePoint;
  219.             }
  220.         ShowMenu(mmAppleMenu);
  221.  
  222.         mmFileMenu = MakeNewMenu("File");
  223.         if (mmFileMenu == NIL)
  224.             {
  225.                 goto MakeFileMenuFailurePoint;
  226.             }
  227.         mNewFile = MakeNewMenuItem(mmFileMenu,"New",'N');
  228.         if (mNewFile == NIL)
  229.             {
  230.                 goto MakeEditMenuFailurePoint;
  231.             }
  232.         mOpenFile = MakeNewMenuItem(mmFileMenu,"Open...",'O');
  233.         if (mOpenFile == NIL)
  234.             {
  235.                 goto MakeEditMenuFailurePoint;
  236.             }
  237.         mCloseFile = MakeNewMenuItem(mmFileMenu,"Close",'W');
  238.         if (mCloseFile == NIL)
  239.             {
  240.                 goto MakeEditMenuFailurePoint;
  241.             }
  242.         AppendSeparator(mmFileMenu);
  243.         mSaveFile = MakeNewMenuItem(mmFileMenu,"Save",'S');
  244.         if (mSaveFile == NIL)
  245.             {
  246.                 goto MakeEditMenuFailurePoint;
  247.             }
  248.         mSaveAs = MakeNewMenuItem(mmFileMenu,"Save As...",0);
  249.         if (mSaveAs == NIL)
  250.             {
  251.                 goto MakeEditMenuFailurePoint;
  252.             }
  253.         AppendSeparator(mmFileMenu);
  254.         mSetTabSize = MakeNewMenuItem(mmFileMenu,"Set Tab Size...",0);
  255.         if (mSetTabSize == NIL)
  256.             {
  257.                 goto MakeEditMenuFailurePoint;
  258.             }
  259.         AppendSeparator(mmFileMenu);
  260.         mPlay = MakeNewMenuItem(mmFileMenu,"Play...",'P');
  261.         if (mPlay == NIL)
  262.             {
  263.                 goto MakeEditMenuFailurePoint;
  264.             }
  265.         mPlayThisTrackFromHere = MakeNewMenuItem(mmFileMenu,"Play This Track",'T');
  266.         if (mPlayThisTrackFromHere == NIL)
  267.             {
  268.                 goto MakeEditMenuFailurePoint;
  269.             }
  270.         mPlayAllTracksFromHere = MakeNewMenuItem(mmFileMenu,"Play All Tracks",'Y');
  271.         if (mPlayAllTracksFromHere == NIL)
  272.             {
  273.                 goto MakeEditMenuFailurePoint;
  274.             }
  275.         AppendSeparator(mmFileMenu);
  276.         mPlayAIFFFile = MakeNewMenuItem(mmFileMenu,"Play AIFF File",0);
  277.         if (mPlayAIFFFile == NIL)
  278.             {
  279.                 goto MakeEditMenuFailurePoint;
  280.             }
  281.         AppendSeparator(mmFileMenu);
  282.         mQuit = MakeNewMenuItem(mmFileMenu,"Quit",'Q');
  283.         if (mQuit == NIL)
  284.             {
  285.                 goto MakeEditMenuFailurePoint;
  286.             }
  287.         ShowMenu(mmFileMenu);
  288.  
  289.         mmEditMenu = MakeNewMenu("Edit");
  290.         if (mmEditMenu == NIL)
  291.             {
  292.                 goto MakeEditMenuFailurePoint;
  293.             }
  294.         mUndo = MakeNewMenuItem(mmEditMenu,"Undo",'Z');
  295.         if (mUndo == NIL)
  296.             {
  297.                 goto MakeSearchMenuFailurePoint;
  298.             }
  299.         AppendSeparator(mmEditMenu);
  300.         mCut = MakeNewMenuItem(mmEditMenu,"Cut",'X');
  301.         if (mCut == NIL)
  302.             {
  303.                 goto MakeSearchMenuFailurePoint;
  304.             }
  305.         mCopy = MakeNewMenuItem(mmEditMenu,"Copy",'C');
  306.         if (mCopy == NIL)
  307.             {
  308.                 goto MakeSearchMenuFailurePoint;
  309.             }
  310.         mPaste = MakeNewMenuItem(mmEditMenu,"Paste",'V');
  311.         if (mPaste == NIL)
  312.             {
  313.                 goto MakeSearchMenuFailurePoint;
  314.             }
  315.         mClear = MakeNewMenuItem(mmEditMenu,"Clear",0);
  316.         if (mClear == NIL)
  317.             {
  318.                 goto MakeSearchMenuFailurePoint;
  319.             }
  320.         mSelectAll = MakeNewMenuItem(mmEditMenu,"Select All",'A');
  321.         if (mSelectAll == NIL)
  322.             {
  323.                 goto MakeSearchMenuFailurePoint;
  324.             }
  325.         AppendSeparator(mmEditMenu);
  326.         mShiftLeft = MakeNewMenuItem(mmEditMenu,"Shift Left",'L');
  327.         if (mShiftLeft == NIL)
  328.             {
  329.                 goto MakeSearchMenuFailurePoint;
  330.             }
  331.         mShiftRight = MakeNewMenuItem(mmEditMenu,"Shift Right",'R');
  332.         if (mShiftRight == NIL)
  333.             {
  334.                 goto MakeSearchMenuFailurePoint;
  335.             }
  336.         mBalanceParens = MakeNewMenuItem(mmEditMenu,"Balance",'B');
  337.         if (mBalanceParens == NIL)
  338.             {
  339.                 goto MakeSearchMenuFailurePoint;
  340.             }
  341.         AppendSeparator(mmEditMenu);
  342.         mTransposeSelection = MakeNewMenuItem(mmEditMenu,"Transpose Selection",0);
  343.         if (mTransposeSelection == NIL)
  344.             {
  345.                 goto MakeSearchMenuFailurePoint;
  346.             }
  347.         mGotoMeasureBar = MakeNewMenuItem(mmEditMenu,"Go To Measure...",0);
  348.         if (mGotoMeasureBar == NIL)
  349.             {
  350.                 goto MakeSearchMenuFailurePoint;
  351.             }
  352.         AppendSeparator(mmEditMenu);
  353.         mShowSelection = MakeNewMenuItem(mmEditMenu,"Show Selection",0);
  354.         if (mShowSelection == NIL)
  355.             {
  356.                 goto MakeSearchMenuFailurePoint;
  357.             }
  358.         ShowMenu(mmEditMenu);
  359.  
  360.         mmSearchMenu = MakeNewMenu("Search");
  361.         if (mmSearchMenu == NIL)
  362.             {
  363.                 goto MakeSearchMenuFailurePoint;
  364.             }
  365.         mEnterSelection = MakeNewMenuItem(mmSearchMenu,"Enter Selection",'E');
  366.         if (mEnterSelection == NIL)
  367.             {
  368.                 goto MakeObjectsMenuFailurePoint;
  369.             }
  370.         mFind = MakeNewMenuItem(mmSearchMenu,"Find...",'F');
  371.         if (mFind == NIL)
  372.             {
  373.                 goto MakeObjectsMenuFailurePoint;
  374.             }
  375.         mFindAgain = MakeNewMenuItem(mmSearchMenu,"Find Again",'G');
  376.         if (mFindAgain == NIL)
  377.             {
  378.                 goto MakeObjectsMenuFailurePoint;
  379.             }
  380.         mReplace = MakeNewMenuItem(mmSearchMenu,"Replace",'=');
  381.         if (mReplace == NIL)
  382.             {
  383.                 goto MakeObjectsMenuFailurePoint;
  384.             }
  385.         mReplaceAndFindAgain = MakeNewMenuItem(mmSearchMenu,"Replace and Find Again",'H');
  386.         if (mReplaceAndFindAgain == NIL)
  387.             {
  388.                 goto MakeObjectsMenuFailurePoint;
  389.             }
  390.         ShowMenu(mmSearchMenu);
  391.  
  392.         mmObjectsMenu = MakeNewMenu("Objects");
  393.         if (mmObjectsMenu == NIL)
  394.             {
  395.                 goto MakeObjectsMenuFailurePoint;
  396.             }
  397.         mDeleteObject = MakeNewMenuItem(mmObjectsMenu,"Delete",0);
  398.         if (mDeleteObject == NIL)
  399.             {
  400.                 goto MakeFunctionMenuFailurePoint;
  401.             }
  402.         AppendSeparator(mmObjectsMenu);
  403.         mOpenObject = MakeNewMenuItem(mmObjectsMenu,"Edit",0);
  404.         if (mOpenObject == NIL)
  405.             {
  406.                 goto MakeFunctionMenuFailurePoint;
  407.             }
  408.         mEditTrackAttributes = MakeNewMenuItem(mmObjectsMenu,"Edit Track Attributes",0);
  409.         if (mEditTrackAttributes == NIL)
  410.             {
  411.                 goto MakeFunctionMenuFailurePoint;
  412.             }
  413.         AppendSeparator(mmObjectsMenu);
  414.         mCopyObject = MakeNewMenuItem(mmObjectsMenu,"Copy Object",0);
  415.         if (mCopyObject == NIL)
  416.             {
  417.                 goto MakeFunctionMenuFailurePoint;
  418.             }
  419.         AppendSeparator(mmObjectsMenu);
  420.         mPasteObject = MakeNewMenuItem(mmObjectsMenu,"Paste Object",0);
  421.         if (mPasteObject == NIL)
  422.             {
  423.                 goto MakeFunctionMenuFailurePoint;
  424.             }
  425.         AppendSeparator(mmObjectsMenu);
  426.         mNewTrack = MakeNewMenuItem(mmObjectsMenu,"New Track",0);
  427.         if (mNewTrack == NIL)
  428.             {
  429.                 goto MakeFunctionMenuFailurePoint;
  430.             }
  431.         mNewInstrument = MakeNewMenuItem(mmObjectsMenu,"New Instrument",0);
  432.         if (mNewInstrument == NIL)
  433.             {
  434.                 goto MakeFunctionMenuFailurePoint;
  435.             }
  436.         mNewWaveTable = MakeNewMenuItem(mmObjectsMenu,"New Wave Table",0);
  437.         if (mNewWaveTable == NIL)
  438.             {
  439.                 goto MakeFunctionMenuFailurePoint;
  440.             }
  441.         mNewAlgoWaveTable = MakeNewMenuItem(mmObjectsMenu,"New Algorithmic Wave Table",0);
  442.         if (mNewAlgoWaveTable == NIL)
  443.             {
  444.                 goto MakeFunctionMenuFailurePoint;
  445.             }
  446.         mNewSample = MakeNewMenuItem(mmObjectsMenu,"New Sample",0);
  447.         if (mNewSample == NIL)
  448.             {
  449.                 goto MakeFunctionMenuFailurePoint;
  450.             }
  451.         mNewAlgoSample = MakeNewMenuItem(mmObjectsMenu,"New Algorithmic Sample",0);
  452.         if (mNewAlgoSample == NIL)
  453.             {
  454.                 goto MakeFunctionMenuFailurePoint;
  455.             }
  456.         mNewFunction = MakeNewMenuItem(mmObjectsMenu,"New Function Module",0);
  457.         if (mNewFunction == NIL)
  458.             {
  459.                 goto MakeFunctionMenuFailurePoint;
  460.             }
  461.         AppendSeparator(mmObjectsMenu);
  462.         mCalculator = MakeNewMenuItem(mmObjectsMenu,"Calculator",0);
  463.         if (mCalculator == NIL)
  464.             {
  465.                 goto MakeFunctionMenuFailurePoint;
  466.             }
  467.         AppendSeparator(mmObjectsMenu);
  468.         mEvaluateCalc = MakeNewMenuItem(mmObjectsMenu,"Evaluate",'D');
  469.         if (mEvaluateCalc == NIL)
  470.             {
  471.                 goto MakeFunctionMenuFailurePoint;
  472.             }
  473.         ShowMenu(mmObjectsMenu);
  474.  
  475.         mmFunctionMenu = MakeNewMenu("Build");
  476.         if (mmFunctionMenu == NIL)
  477.             {
  478.                 goto MakeFunctionMenuFailurePoint;
  479.             }
  480.         mBuildFunction = MakeNewMenuItem(mmFunctionMenu,"Compile",'K');
  481.         if (mBuildFunction == NIL)
  482.             {
  483.                 goto MakeSampleMenuFailedPoint;
  484.             }
  485.         AppendSeparator(mmFunctionMenu);
  486.         mUnbuildFunction = MakeNewMenuItem(mmFunctionMenu,"Remove Objects For This",0);
  487.         if (mUnbuildFunction == NIL)
  488.             {
  489.                 goto MakeSampleMenuFailedPoint;
  490.             }
  491.         mUnbuildAllFunctions = MakeNewMenuItem(mmFunctionMenu,"Remove Objects For All",0);
  492.         if (mUnbuildAllFunctions == NIL)
  493.             {
  494.                 goto MakeSampleMenuFailedPoint;
  495.             }
  496.         mBuildEntireProject = MakeNewMenuItem(mmFunctionMenu,"Build All Objects",'U');
  497.         if (mBuildEntireProject == NIL)
  498.             {
  499.                 goto MakeSampleMenuFailedPoint;
  500.             }
  501.         AppendSeparator(mmFunctionMenu);
  502.         mDisassembleFunction = MakeNewMenuItem(mmFunctionMenu,"Disassemble",0);
  503.         if (mDisassembleFunction == NIL)
  504.             {
  505.                 goto MakeSampleMenuFailedPoint;
  506.             }
  507.         AppendSeparator(mmFunctionMenu);
  508.         mAlgoSampToSample = MakeNewMenuItem(mmFunctionMenu,"Open Algorithmic Sample As New Sample",0);
  509.         if (mAlgoSampToSample == NIL)
  510.             {
  511.                 goto MakeSampleMenuFailedPoint;
  512.             }
  513.         ShowMenu(mmFunctionMenu);
  514.  
  515.         mmSampleMenu = MakeNewMenu("Samples");
  516.         if (mmSampleMenu == NIL)
  517.             {
  518.                 goto MakeSampleMenuFailedPoint;
  519.             }
  520.         mSampleEditLoop1 = MakeNewMenuItem(mmSampleMenu,"Edit Loop 1",'1');
  521.         if (mSampleEditLoop1 == NIL)
  522.             {
  523.                 goto MakeWindowMenuFailedPoint;
  524.             }
  525.         mSampleEditLoop2 = MakeNewMenuItem(mmSampleMenu,"Edit Loop 2",'2');
  526.         if (mSampleEditLoop2 == NIL)
  527.             {
  528.                 goto MakeWindowMenuFailedPoint;
  529.             }
  530.         mSampleEditLoop3 = MakeNewMenuItem(mmSampleMenu,"Edit Loop 3",'3');
  531.         if (mSampleEditLoop3 == NIL)
  532.             {
  533.                 goto MakeWindowMenuFailedPoint;
  534.             }
  535.         AppendSeparator(mmSampleMenu);
  536.         mImportWAVFormat = MakeNewMenuItem(mmSampleMenu,"Import WAV Sample",0);
  537.         if (mImportWAVFormat == NIL)
  538.             {
  539.                 goto MakeWindowMenuFailedPoint;
  540.             }
  541.         mImportAIFFFormat = MakeNewMenuItem(mmSampleMenu,"Import AIFF Sample",0);
  542.         if (mImportAIFFFormat == NIL)
  543.             {
  544.                 goto MakeWindowMenuFailedPoint;
  545.             }
  546.         mImportRAWFormat = MakeNewMenuItem(mmSampleMenu,"Import Raw Sample",0);
  547.         if (mImportRAWFormat == NIL)
  548.             {
  549.                 goto MakeWindowMenuFailedPoint;
  550.             }
  551.         AppendSeparator(mmSampleMenu);
  552.         mExportWAVFormat = MakeNewMenuItem(mmSampleMenu,"Export WAV Sample",0);
  553.         if (mExportWAVFormat == NIL)
  554.             {
  555.                 goto MakeWindowMenuFailedPoint;
  556.             }
  557.         mExportAIFFFormat = MakeNewMenuItem(mmSampleMenu,"Export AIFF Sample",0);
  558.         if (mExportAIFFFormat == NIL)
  559.             {
  560.                 goto MakeWindowMenuFailedPoint;
  561.             }
  562.         mExportRAWFormat = MakeNewMenuItem(mmSampleMenu,"Export Raw Sample",0);
  563.         if (mExportRAWFormat == NIL)
  564.             {
  565.                 goto MakeWindowMenuFailedPoint;
  566.             }
  567.         ShowMenu(mmSampleMenu);
  568.  
  569.         mmWindowMenu = MakeNewMenu("Windows");
  570.         if (mmWindowMenu == NIL)
  571.             {
  572.                 goto MakeWindowMenuFailedPoint;
  573.             }
  574.         ShowMenu(mmWindowMenu);
  575.  
  576.         PrepareStartupDocuments(argc,argv);
  577.         TryToOpenUntitledDocument = True;
  578.         ContinueFlag = True;
  579.         while (ContinueFlag)
  580.             {
  581.                 OrdType                    XLoc;
  582.                 OrdType                    YLoc;
  583.                 ModifierFlags        Modifiers;
  584.                 FileSpec*                StartupItem;
  585.                 WinType*                Window;
  586.                 char                        KeyPress;
  587.                 MenuItemType*        MenuItem;
  588.                 EventType                TheEvent;
  589.  
  590.                 /* see if there are any startup items to open */
  591.                 if (GetStartupObject(&StartupItem))
  592.                     {
  593.                         /* if it returns True, then we can go ahead */
  594.                         if (StartupItem == NIL)
  595.                             {
  596.                                 /* if we haven't opened an untitled document, and the thing */
  597.                                 /* returned True, except it returned a NIL item, then we */
  598.                                 /* can open an untitled document */
  599.                                 if (TryToOpenUntitledDocument)
  600.                                     {
  601.                                         OpenDocument(NIL);
  602.                                         TryToOpenUntitledDocument = False;
  603.                                     }
  604.                             }
  605.                          else
  606.                             {
  607.                                 /* if it isn't NIL, then open the actual thing */
  608.                                 /* this swallows the startup item record so we don't have */
  609.                                 /* do dispose of it */
  610.                                 OpenDocument(StartupItem);
  611.                                 TryToOpenUntitledDocument = False;
  612.                             }
  613.                     }
  614. #if 0
  615.                 if (InitialAboutBoxStillVisible)
  616.                     {
  617.                         if (TimerDifference(ReadTimer(),StartupTime) > STARTUPDELAY)
  618.                             {
  619.                                 InitialAboutBoxStillVisible = False;
  620.                                 HideAnyAboutBoxes();
  621.                             }
  622.                     }
  623. #endif
  624.                 TheEvent = GetAnEvent(&XLoc,&YLoc,&Modifiers,&Window,&MenuItem,&KeyPress);
  625.                 switch (TheEvent)
  626.                     {
  627.                         case eMouseUp:
  628.                             break;
  629.                         case eMenuStarting:
  630.                             EnableMenuItem(mAboutThisProgram);
  631.                             EnableMenuItem(mNewFile);
  632.                             EnableMenuItem(mOpenFile);
  633.                             EnableMenuItem(mQuit);
  634.                             EnableMenuItem(mPlayAIFFFile);
  635.                             DispatchMenuStarting(Window);
  636.                             break;
  637.                         case eMenuCommand:
  638.                             if (MenuItem == mAboutThisProgram)
  639.                                 {
  640.                                     ShowAboutBox();
  641.                                 }
  642.                             else if (MenuItem == mOpenFile)
  643.                                 {
  644.                                     FileSpec*                    Where;
  645.                                     unsigned long            FileTypeList[1] = {ApplicationFileType};
  646.  
  647.                                     Where = GetFileStandard(1,FileTypeList);
  648.                                     if (Where != NIL)
  649.                                         {
  650.                                             OpenDocument(Where);
  651.                                         }
  652.                                 }
  653.                             else if (MenuItem == mNewFile)
  654.                                 {
  655.                                     OpenDocument(NIL);
  656.                                 }
  657.                             else if (MenuItem == mQuit)
  658.                                 {
  659.                                     SetQuitPending();
  660.                                 }
  661.                             else if (MenuItem == mPlayAIFFFile)
  662.                                 {
  663.                                     PlayAIFFFile();
  664.                                 }
  665.                             else
  666.                                 {
  667.                                     DispatchProcessMenuCommand(Window,MenuItem);
  668.                                 }
  669.                             break;
  670.                         case eKeyPressed:
  671.                             DispatchDoKeyDown(Window,KeyPress,Modifiers);
  672.                             break;
  673.                         case eMouseDown:
  674.                             DispatchDoMouseDown(Window,XLoc,YLoc,Modifiers);
  675.                             break;
  676.                         case eWindowClosing:
  677.                             DispatchCloseWindow(Window);
  678.                             break;
  679.                         case eWindowResized:
  680.                             DispatchWindowJustResized(Window);
  681.                             break;
  682.                         case eActiveWindowChanged:
  683.                             DispatchActiveWindowJustChanged(Window);
  684.                             break;
  685.                         case eNoEvent:
  686.                         case eCheckCursor:
  687.                             DispatchDoIdle(Window,TheEvent == eCheckCursor,XLoc,YLoc,Modifiers);
  688.                             break;
  689.                         default:
  690.                             EXECUTE(PRERR(AllowResume,"Unimplemented event received"));
  691.                             break;
  692.                     }
  693.                 if (CheckQuitPending())
  694.                     {
  695.                         /* ask "are you sure" here; */
  696.                         DoCloseAllQuitPending();
  697.                         if (CheckQuitPending())
  698.                             {
  699.                                 /* if quit is still pending, then we exit */
  700.                                 ContinueFlag = False;
  701.                             }
  702.                     }
  703.             }
  704.         ClearStartupDocuments();
  705.  
  706.  
  707.         /* application cleanup */
  708.      LastMenuConstructionFailurePoint:
  709.         KillMenuAndDeleteItems(mmWindowMenu);
  710.      MakeWindowMenuFailedPoint:
  711.         KillMenuAndDeleteItems(mmSampleMenu);
  712.      MakeSampleMenuFailedPoint:
  713.         KillMenuAndDeleteItems(mmFunctionMenu);
  714.      MakeFunctionMenuFailurePoint:
  715.         KillMenuAndDeleteItems(mmObjectsMenu);
  716.      MakeObjectsMenuFailurePoint:
  717.         KillMenuAndDeleteItems(mmSearchMenu);
  718.      MakeSearchMenuFailurePoint:
  719.         KillMenuAndDeleteItems(mmEditMenu);
  720.      MakeEditMenuFailurePoint:
  721.         KillMenuAndDeleteItems(mmFileMenu);
  722.      MakeFileMenuFailurePoint:
  723.         KillMenuAndDeleteItems(mmAppleMenu);
  724.      MakeAppleMenuFailurePoint:
  725.         HideAnyAboutBoxes();
  726.         ShutdownGlobalWindowMenuList();
  727.      InitializeGlobalMenuWindowListFailurePoint:
  728.         ReleasePtr(GlobalReplaceString);
  729.      AllocGlobalReplaceStringFailurePoint:
  730.         ReleasePtr(GlobalSearchString);
  731.      AllocGlobalSearchStringFailurePoint:
  732.         ShutdownDocuments();
  733.      InitDocumentsFailurePoint:
  734.         ShutdownWindowDispatcher();
  735.      InitializeLittleButtonImagesFailurePoint:
  736.         ShutdownLittleButtonImages();
  737.      InitWindowDispatcherFailurePoint:
  738.         CleanupNoteButtonImages();
  739.      InitNoteButtonImagesFailurePoint:
  740.         CleanupNoteImages();
  741.      InitNoteImagesFailurePoint:
  742.         CleanupEditImages();
  743.      InitEditImagesFailurePoint:
  744.         ShutdownFactoring();
  745.  
  746.      InitFactoringFailurePoint:
  747.         /* level 1 cleanup */
  748.         ShutdownGrowIcon();
  749.      InitGrowIconFailurePoint:
  750.         ShutdownAlertSubsystem();
  751.  
  752.      InitAlertFailurePoint:
  753.         /* level 0 cleanup */
  754.         ShutdownScreen();
  755.  
  756.      InitScreenFailurePoint:
  757.         APRINT(("-main"));
  758.         return 0;
  759.     }
  760.